package com.emergency.evaluate.service.impl;

import com.emergency.evaluate.dao.ManualDao;
import com.emergency.evaluate.domain.Manual;
import com.emergency.evaluate.service.FuzzyEvaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import static java.lang.Math.log;

/**
 * Created by Administrator on 2020/5/8.
 */
@Service
public class fuzzyEvaServiceImpl  implements FuzzyEvaService{

    @Autowired
    private  ManualDao manualDao;
    //模糊综合评价法，计算模糊矩阵和指标权重
    //导入需要人工评价的评价指标得分

    public void add(List<Manual> manualList){

        double scorelist[][] = new double[0][]; //建立分数数据集
        /*因为评分专家有多个，因此利用模糊综合评价计算演练评估总分和单项得分
        *格式如下
        *    得分                评价指标1        评价指标2     评价指标3   ....
        *    专家1 打分
        *    专家2 打分
        *    ....
        *    */
        int nrows=0; //获取总共参与评分的专家人数，scorelist 总行数
        int scoreRows=0;
        for (Manual manual:manualList){

            scoreRows=manual.getScores ().size ();  //统计评分指标数量   scorelist 总列数
            //获取数据集
            for(int i=0;i<scoreRows;i++){
                scorelist[nrows][i]=manual.getScores ().get (i).getScore ();
            }
            nrows++;
        }

        //分为四个等级，A/B/C/D/E，评价指标
        float du[][]=new float[scoreRows][5];   //模糊综合评判矩阵
        int Anum=0,Bnum=0,Cnum=0,Dnum=0,Enum=0;//用于计算所有专家同一指标评分等级个数
        for(int j=0;j<scoreRows;j++)
        for (int i=0;i<nrows;i++){
            if (scorelist[i][j]< 100 && (scorelist[i][j]>= 90)) {
                Anum+=1;
            } else if (scorelist[i][j]<90 && (scorelist[i][j]>= 80)) {
                Bnum+=1;
            } else if (scorelist[i][j]< 80 && (scorelist[i][j]>= 70)) {
                Cnum+=1;
            } else if (scorelist[i][j] < 70 && (scorelist[i][j] >= 60)) {
                Dnum+=1;
            } else if (scorelist[i][j]< 60) {
               Enum+=1;
            }
            //每个等级下的概率
            float pA=Anum/nrows,pB=Bnum/nrows,pC=Cnum/nrows,pD=Dnum/nrows,pE=Enum/nrows;
            du[j][0]=pA;
            du[j][1]=pB;
            du[j][2]=pC;
            du[j][3]=pD;
            du[j][4]=pE;
        }
        List<Float> listSum = new ArrayList<Float>();	//用于存放每种指标下所有记录归一化后的和
        List<Double> gList = new ArrayList<Double>();	//用于存放每种指标的差异系数
        List<Double> wList = new ArrayList<Double>();	//用于存放每种指标的最终权重系数
        float sumLast = 0;
        float k = (float) (1 / Math.log(du[0].length)); //计算k值 k= 1/ln(n)
        /**
         * 利用熵值法确定权重
         * @author Beat IT
         *
         */
        //数据归一化处理	(i-min)/(max-min)
        for (int i = 0; i < du.length; i++) {
           float sum = 0;
            float max=0,min=0;
            for(int j=0;j<du[i].length;j++)
            { max =(du[i][j]>max? du[i][j]:max);
              min =(du[i][j]<min? du[i][j]:min);
             float temp = (du[i][j]- min) / (max - min);
                sum += temp;
                du[i][j]=temp;
            }
            listSum.add(sum);
        }

        //计算每项指标下每个记录所占比重
        for (int i = 0; i <du.length; i++) {
            double sum = 0;	//每种指标下所有记录权重和
            for (int j = 0; j <scoreRows; j++) {
                if(du[i][j] / listSum.get(i) == 0){
                    sum +=0;
                }else{
                    sum += (du[i][j] / listSum.get(i)) * Math.log(du[i][j]/ listSum.get(i));
                }

            }
        //计算第i项指标的熵值
        double e = -k * sum;
        //计算第j项指标的差异系数
        double g = 1-e;
        sumLast += g;
        gList.add(g);
            }
     //计算每项指标的权重
            for (int i = 0; i < gList.size(); i++) {
                wList.add(gList.get(i) / sumLast);
            }
    //wlist 为权重矩阵

        }

}
